home *** CD-ROM | disk | FTP | other *** search
/ Floppyshop 2 / Floppyshop - 2.zip / Floppyshop - 2.iso / diskmags / 0022-3.564 / dmg-3313 / news.txt / pascal3.asc < prev    next >
Text File  |  1989-04-05  |  11KB  |  320 lines
  1.  
  2.      --------------------------------------------------------------
  3.  
  4.      PPPPPP      AAAAA      SSSS S     CCCCC      AAAAA      LL
  5.      PP   PP    AA   AA    SS   SS    CC    C    AA   AA     LL
  6.      PP   PP    AA   AA    SS         CC         AA   AA     LL
  7.      PPPPPP     AAAAAAA     SSSSS     CC         AAAAAAA     LL
  8.      PP         AA   AA         SS    CC         AA   AA     LL
  9.      PP         AA   AA    SS   SS    CC    C    AA   AA     LL
  10.      PP         AA   AA    S SSSS      CCCCC     AA   AA     LLLLLLL
  11.  
  12.      ===============================================================
  13.  
  14.                    TUTORIAL PART 3 - BY DEREK CLEGG
  15.  
  16.      ---------------------------------------------------------------
  17.  
  18.  
  19.  Last time I left you two short (but sweet) problems to solve  in  Pascal. 
  20. As  yet I have not delved into the art of problem solving and so  that  is 
  21. what  I  intend  to do now.  To demonstrate  the  problem  solving  method 
  22. programmers  use (called stepwise refinement or top down design),  I  will 
  23. use problem one from last STEN as the problem to be solved!!
  24.  
  25.  What 'Top down design' really is,  is the breaking up of a  problem  down 
  26. into smaller sub-problems and repeatedly breaking  each sub-problem into a 
  27. further sub-problem until all of the  sub-problems are in or very near the 
  28. target language you will be  coding your program in.  The actual  language 
  29. used  in stepwise  refinement is called psuedo code and has very few  'key 
  30. words'.
  31.  
  32.  Lets start by analysing the problem to arrive at our 'Top  level  design' 
  33. of  the problem.  The first thing you should notice is  that  an  asterisk 
  34. marks  the end of the names in the file also each  name is separated by  a 
  35. slash ie '/'.  As with nearly all program  specifications, there have been 
  36. some  things  omitted  such as it  doesn't say  that  there  are  carriage 
  37. returns after each name. So  for the purpose of this exercise we'll assume 
  38. that  all the names  in the file will be on the same line ie the  file  is 
  39. just one big  long stream of single characters.
  40.  
  41.  
  42.  From this you should arrive at a top-level design similar to:-
  43.  
  44.         BEGIN 
  45.           Open files; 
  46.           WHILE data remains DO 
  47.                 Copy a name;            1.1 
  48.         END.
  49.  
  50.  At any stage of your design of a solution to a given problem  you  should 
  51. be  able to look at your design and see that it will  solve the  task.  At 
  52. the moment are design is very brief and simplistic yet if you look at  it, 
  53. it does actually solve the problem!  So now we must take our  sub-problem, 
  54. 'Copy  a name',  and see can we refine it a little bit.  Never try to  get 
  55. down to your chosen language to soon.
  56.  
  57.  
  58. 1.1 Refinement of 'Copy a name'.
  59. --------------------------------
  60.  
  61.         BEGIN 
  62.           WHILE its not the end of the name DO 
  63.                 copy a single character              1.1.1 
  64.         END;
  65.  
  66.  
  67.   Look  at  your refinement to copy a name and  ask  yourself  does   this 
  68. refinement solve the problem of actually copying one name.  Although it is 
  69. simplistic and can be refined further still,  it  does actually solve  the 
  70. task of copying one name.  So now lets  look at the process of copying one 
  71. character.
  72.  
  73.  
  74. 1.1.1  Refinement of 'Copy a character'.
  75. ----------------------------------------
  76.  
  77.         BEGIN 
  78.           Read in character from input file; 
  79.           Write out character to output file 
  80.         END;
  81.  
  82.  
  83.   Thus  we  have reached the stage where our psuedo code  can  be   easily 
  84. converted into Pascal (or any language for that matter) and  so we can now 
  85. write  the  actual  Pascal code.  We will need an  input   file  of  ASCII 
  86. characters  which we'll call 'Namesin.dat' and the  program will send  the 
  87. output to a file called 'Namesout.dat'.
  88.  
  89.  
  90.         PROGRAM CopyNames (NamesIn, NamesOut);
  91.  
  92.                 CONST   EndOfData = '*'; 
  93.                         EndOfName = '/';
  94.  
  95.  
  96.  
  97.                 PROCEDURE CopyACharacter;
  98.  
  99.                    VAR   Ch : CHAR;  (* ~Note~ Ch is a local variable *)
  100.  
  101.                    BEGIN 
  102.                      READ ( NamesIn, Ch ); 
  103.                      WRITE ( NamesOut, Ch ) 
  104.                    END;
  105.  
  106.  
  107.  
  108.                 PROCEDURE CopyAName; 
  109.                    BEGIN 
  110.                      WHILE NamesIn∧ <> EndOfName DO 
  111.                         CopyACharacter 
  112.                    END;
  113.  
  114.  
  115.                 PROCEDURE OpenFiles; 
  116.                    BEGIN 
  117.                      (* Open input file for reading from *) 
  118.                      RESET ( NamesIn ); 
  119.                      (* Open output file for writimg to *) 
  120.                      REWRITE ( NamesOut ) 
  121.                    END;
  122.  
  123.  
  124.                 BEGIN                             (* Main program *) 
  125.                   OpenFiles; 
  126.                   WHILE NamesIn∧ <> EndOfData DO 
  127.                     BEGIN 
  128.                       CopyAName;                  (* Refinement 1.1 *) 
  129.                     END 
  130.                 END                               (* End of main *).
  131.  
  132.  
  133.  
  134.  
  135.  Here follows the Pascal code for a solution to task 2 from  STEN 9. 
  136.  
  137.         PROGRAM  Distances ( Input, Output );
  138.  
  139.           CONST Yard = 36; 
  140.             Foot = 12;
  141.  
  142.           VAR   Feet, Yards, Inches, Count : INTEGER; 
  143.                     Tot_Yards, Tot_Feet, Tot_Inches : INTEGER;
  144.  
  145.         (* The procedures used! *)
  146.  
  147.           PROCEDURE GetDistance; 
  148.                 BEGIN 
  149.                   (* Prompt user to enter a measurement *) 
  150.                   WRITELN('Enter your measurement in inches please.');
  151.  
  152.                   (* Accept measurement from user *) 
  153.                   READLN( Inches ) 
  154.                 END;
  155.  
  156.           PROCEDURE Process; 
  157.                 BEGIN 
  158.                    Yards := Inches DIV Yard; 
  159.                   Inches := Inches MOD Yard; 
  160.                     Feet := Inches DIV Foot; 
  161.                   Inches := Inches MOD Foot;
  162.  
  163.                 (* Update running totals. *) 
  164.                    Tot_Yards := Tot_yards + Yards; 
  165.                     Tot_Feet := Tot_feet + feet; 
  166.                   Tot_inches := Tot_inches + Inches 
  167.                 END;
  168.  
  169.           PROCEDURE Output; 
  170.                 BEGIN 
  171.                   WRITELN;   WRITELN; 
  172.                   WRITE(Yards:2,' Yards ',Feet:2,' feet and '); 
  173.                   WRITELN(Inches:2,' inches.') 
  174.                 END;
  175.  
  176.  
  177.           BEGIN         (* Start of main program *) 
  178.                 FOR Count := 1 TO 10 DO 
  179.                    BEGIN 
  180.                      GetDistance; 
  181.                      Process; 
  182.                      Output 
  183.                    END; 
  184.                 WRITELN; 
  185.                 WRITELN('Totals are :- '); 
  186.                 WRITE(Tot_yards:4,' Yards ',Tot_feet:4,' feet and '); 
  187.                 WRITELN(Tot_inches:4,' inches.') 
  188.           END.
  189.  
  190.  
  191.  
  192.                                 ~~~OOOO~~~
  193.  
  194.  
  195. An approach to problem solving.
  196. -------------------------------
  197.  
  198.  A possible approach could be summarised inthe diagram;
  199.  
  200.   ___________       ___________       _________       ____ 
  201.  |Specify the| <-> |Analyse the| <-> |Implement| <-> |test the| 
  202.  | problem   |     | problem   |     |solution |     |solution| 
  203.   -----------       -----------       ---------       -------- 
  204.       |                  |                |               | 
  205.       |                  |                |               | 
  206.   _____________________________________________________________ 
  207.  |                  D o c u m e n t a t i o n                  | 
  208.   -------------------------------------------------------------
  209.  
  210.  
  211.  Specifying the problem - this involves understanding thoroughly 
  212.                           the problem to be solved AND defining 
  213.                           PRECISELY the Input and output.
  214.  
  215.                Analysis - involves understanding the problem, and creating 
  216.                           a manual solution of the problem.
  217.  
  218.                    ( Top-down design & stepwise refinement ).
  219.  
  220.          Implementation - Pseudo code ------> target language 
  221.                           Debugging
  222.  
  223.  
  224.  
  225.   Here  follows  a  simple analysis  to  problem  solving  using  stepwise  
  226. refinement.
  227.  
  228.         BEGIN 
  229.           Break problem into a sequence of sub-problems.
  230.           REPEAT 
  231.                 Break each sub-problem into a sequence of smaller 
  232.            sub-problems 
  233.           UNTIL each sub-problem is expressed in the target language.
  234.  
  235.  
  236.  
  237. Parameters.
  238. -----------
  239.  
  240.   A procedure may be used to define an action,  which is required at  one, 
  241. two or more points in a program.
  242.  
  243.  
  244.  Q - What if the same action is to be performed on different  data?
  245.  
  246. eg. A delay of varying lengths may be required at different  points within 
  247. a  program.  Where  the  following code is  the  main  program,  the  line 
  248. delay(100)  calls the procedure 'delay' and passes a value of 100  to  the 
  249. procedure  to use as the delay.   Thus the line delay(200) calls the  same 
  250. procedure 'delay' and this time passes a value of 200 as the time delay. 
  251.  
  252.  
  253.                 BEGIN 
  254.                   delay(100); 
  255.                   ------- 
  256.                   ------- 
  257.                   delay(200) 
  258.                 END.
  259.  
  260.  
  261.  Thus by passing a different value each time,  that the delay changes,  to 
  262. the procedure delay,  it is avoids having to write two procedures one that 
  263. delays for 100 and one that delays for 200.
  264.  
  265.  
  266.  Here is the correct syntax for the delay procedure;
  267.  
  268.         PROCEDURE delay ( time : Integer );
  269.  
  270.            VAR Idx : Integer;
  271.  
  272.            BEGIN 
  273.              FOR Idx := 1 TO time DO 
  274.            END;
  275.  
  276.  
  277.  In the above procedure the variable 'time' is actually a value parameter, 
  278. which will take the value of any integer value passed to  this procedure!
  279.  
  280.   On entry to the procedure 'delay' a new local variable called 'time'  is 
  281. created which takes the value that was passed into the procedure. On exit, 
  282. the variable no longer exists.
  283.  
  284.                                 ~~~OOOO~~~
  285.         
  286.  
  287.  Next month I'll introduce you to the idea of variable parameters and I'll 
  288. expand  a  little  on  both  value  and  variable  parameters  and   local 
  289. variables.
  290.  
  291.  
  292.   i)  Write  a procedure which sorts two integers  (which  will  be   it's 
  293. parameters) into ascending order.  Then incorporate that pro-  cedure into 
  294. a program which gets three integers from the keyboard  and sorts the three 
  295. numbers into ascending order.
  296.  
  297.  
  298.  ii)  Write a procedure to output to screen a specified character a number 
  299. of times.  The character to output can change each time the  procedure  is 
  300. called and so to can the number of times the character  is to be output.
  301.  
  302.  
  303. iii)   Write a program to validate a date in the form DD/MM/YY  where  the 
  304. year lies between 1901 - 1976.
  305.  
  306.         eg      REPEAT 
  307.                    READLN ( dd,ch,mm,ch,yy ); 
  308.                    Validate ( dd,mm,yy, Valid ); 
  309.                    IF Valid 
  310.                       THEN WRITELN ( 'The date is valid!' ) 
  311.                       ELSE WRITELN ('Invalid date!'); 
  312.                 UNTIL yy = 0
  313.  
  314.  
  315.  
  316.  
  317.  
  318.  
  319.  
  320.